﻿#include<iostream>
using namespace std;

//inline int Add(int x, int y)
//{
//	int ret = x + y;
//	ret += 1;
//	return ret;
//}

//#include"Test.h"
//int Add(int x, int y)
//{
//	int ret = x + y;
//	ret += 1;
//	return ret;
//}
//
//int main()
//{
//	cout << Add(1, 2) * 5 << endl;
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//// 实现⼀个ADD宏函数的常见问题 
////#define ADD(int a, int b) return a + b; //err
////#define ADD(a, b) a + b; //err
////#define ADD(a, b) (a + b)//err
//// 正确的宏实现 
//#define ADD(a, b) ((a) + (b))
//// 1.为什么不能加分号? 
//// 2.为什么要加外面的括号? 
//// 3.为什么要加里面的括号? 
//int main()
//{
//	cout << ADD(1, 2) << endl;//1.
//	cout << ADD(1, 2) * 5 << endl;//2.
//	cout << ADD(1 & 2, 1 | 2) << endl; //  (1&2+1|2) +的优先级更高  //3.
//
//	return 0;
//}


//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//
//int main()
//{
//	f(0);
//	f(NULL);//NULL被定义为0
//	//f((void*)NULL);//err
//	f((int*)NULL);
//	
//	f(nullptr);
//	return 0;
//}

//int main()
//{
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr);
//	cout.tie(nullptr);
//	return 0;
//}

//int main()
//{
//	//这里的引用是对a访问权限的缩小
//	int b = 10;
//	const int& rb = b;
//
//	//const修饰对象不可修改
//	b++;
//	//rb++; //err
//
//	cout << b << endl;
//	cout << rb << endl;
//	return 0;
//}

//int main()
//{
//	double d = 12.34;
//	//int& rd = d;    //err
//	const int& rd = d;
//
//	cout << rd << endl;
//	return 0;
//}

//int& f()
//{
//	int a = 0;
//	return a;
//}
//
//int main()
//{
//	cout << f() << endl;
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//
//int main()
//{
//	f(nullptr);
//
//	return 0;
//}


//#include<stdio.h>
//
//namespace zsy
//{
//	int a = 0;
//	int b = 1;
//}
//
//using namespace zsy;//展开命名空间中全部成员
//int main()
//{
//	printf("%d\n", a);
//	printf("%d\n", b);
//
//	return 0;
//}



//#include<assert.h>
//
//class Stack
//{
//public:
//
//	//成员函数
//	void Init(int n = 4)
//	{
//		a = (int*)malloc(sizeof(int) * n);
//		if (a == nullptr) 
//		{
//			perror("malloc fail");
//			return;
//		}
//
//		capacity = n;
//		top = 0;
//	}
//
//	void Push(int x)
//	{
//		//...扩容
//		a[top++] = x;
//	}
//
//	int Top()
//	{
//		assert(top > 0);
//		return a[top - 1];
//	}
//
//	void Destroy()
//	{
//		free(a);
//		a = nullptr;
//		top = capacity = 0;
//	}
//
//private:
//
//	//成员变量
//	int* a;
//	int top;
//	int capacity;
//};
//
//int main()
//{
//	Stack st;
//	st.Init();
//	st.Push(1);
//	st.Push(2);
//	cout << st.Top() << endl;
//	st.Destroy();
//	return 0;
//}

//class Date
//{
//public:
//
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//private:
//
//	int _year;//_year或m_year等等
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d;
//	d.Init(2025, 7, 29);
//
//	return 0;
//}



// C++升级struct升级成了类 
// 1、类里面可以定义函数 
// 2、struct名称就可以代表类型 
// C++兼容C中struct的用法 
// 
// // 不再需要typedef，ListNodeCPP就可以代表类型 

////C
//typedef struct ListNodeC
//{
//	struct ListNodeC* next;
//	int val;
//
//}LTNode;
//
////C++
//struct ListNodeCpp
//{
//	void Init(int x)
//	{
//		next = nullptr;
//		val = x;
//	}
//
//	ListNodeCpp* next;
//	int val;
//};

//class Stack
//{
//public:
//	void Init(int n = 4);
//
//private:
//	int* a;
//	int top;
//	int capacity;
//};
//
////声明和定义分离时，定义要指定类域
//void Stack::Init(int n)
//{
//	a = (int*)malloc(sizeof(int) * n);
//	if (a == nullptr)
//	{
//		perror("malloc fail");
//		return;
//	}
//
//	capacity = n;
//	top = 0;
//}
//
//int main()
//{
//	Stack st;
//	st.Init();
//
//	return 0;
//}

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	//这里只是声明，并没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//Date类实例化出对象d1和d2
//	Date d1;
//	Date d2;
//
//	d1.Init(2025,5,1);
//	d1.Print();
//
//	d2.Init(2025, 7, 29);
//	d2.Print();
//
//	return 0;
//}


//class A
//{
//public:
//	void Print()
//	{
//		cout << _ch << endl;
//	}
//
//private:
//	char _ch;
//	char _i;
//};
//
//class B
//{
//public:
//	void Print()
//	{
//		//...
//	}
//};
//
//class C
//{
//
//};
//
//int main()
//{
//	A a;
//	B b;
//	C c;
//	cout << sizeof(a) << endl;
//	cout << sizeof(b) << endl;
//	cout << sizeof(c) << endl;
//
//	return 0;
//}


//class A
//{
//public:
//	void Print()
//	{
//		cout << "A::Print( )" << endl;
//		cout << _a << endl;
//	}
//
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//
//	return 0;
//}


//#include<stdio.h>
//#include<stdlib.h>
//#include<stdbool.h>
//#include<assert.h>
//
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//
//void STInit(ST* ps)
//{
//	assert(ps);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//
//void STDestroy(ST* ps)
//{
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//
//void STPush(ST* ps, STDataType x)
//{
//	assert(ps);
//	//检查空间大小
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//	//插入数据
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//
//bool STEmpty(ST* ps)
//{
//	assert(ps);
//	return ps->top == 0;
//}
//
//void STPop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	ps->top--;
//}
//
//STDataType STTop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	return ps->a[ps->top - 1];
//}
//
//int STSize(ST* ps)
//{
//	assert(ps);
//	return ps->top;
//}
//
//int main()
//{
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//	while (!STEmpty(&s))
//	{
//		printf("%d\n", STTop(&s));
//		STPop(&s);
//	}
//	STDestroy(&s);
//	return 0;
//}

#include<assert.h>
#include<stdbool.h>
typedef int SLDataType;
class Stack
{
public:
	//成员函数
	void Init(int n = 4)
	{
		_a = (SLDataType*)malloc(sizeof(SLDataType) * n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			return;
		}

		_capacity = n;
		_top = 0;
	}

	void Push(SLDataType x)
	{
		//检查空间大小
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			SLDataType* tmp = (SLDataType*)realloc(_a, sizeof(SLDataType) * newcapacity);
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}

			_a = tmp;
			_capacity = newcapacity;
		}
		//插入数据
		_a[_top++] = x;
	}

	void Pop()
	{
		assert(_top > 0);
		--_top;
	}

	bool Empty()
	{
		return _top == 0;
	}

	int	Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	//成员变量
	SLDataType* _a;
	int _capacity;
	int _top;
};

int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();

	return 0;
}